home *** CD-ROM | disk | FTP | other *** search
/ Languguage OS 2 / Languguage OS II Version 10-94 (Knowledge Media)(1994).ISO / language / embedded / ibm / sym_r3.arc / INSTR.C next >
C/C++ Source or Header  |  1991-11-27  |  21KB  |  688 lines
  1. /********
  2.     program: 68705R3 simulator
  3.     file: instr.c - instruction table, instruction and interrupt
  4.         simulation.  See instr2.c for individual instruction
  5.         routines.
  6.     Author: Joseph Schachner
  7.     Notes: 
  8. ********/
  9.  
  10. #include <stdio.h>
  11. #include "sim.h"
  12.  
  13. #ifdef MSC
  14. #include <dos.h>
  15. #endif
  16.  
  17. extern FILE *logfile;
  18.  
  19. extern unsigned int sym_nmbr[];
  20. extern char sym_tbl[];
  21.  
  22. struct instruction_table_entry {
  23.     PFI function;
  24.     int argument;
  25.     char *name;
  26.     int ncycles;
  27. };
  28.  
  29. /* The following three items are filled by routines in here and instr2
  30.    and are printed out nicely formatted from sim_instr, below 
  31. */
  32. char mne[40];
  33. char opcode[40];
  34. char rw[40];
  35.  
  36. /* Part of this string is used to fill between fields, as needed */
  37. char blanks[]="                                        ";  /* 40 blanks */
  38.  
  39. char inval_str[]="Invalid op";
  40.  
  41. invalid( mode)
  42. int mode;
  43. {
  44.     sim_halt();
  45. }
  46.  
  47. extern int brset(),brclr(),bset(),bclr(),branch(),neg(),mul();
  48. extern int com(),lsr(),ror(),asr(),lsl(),rol(),dec(),inc(),tst(),clr(),rti();
  49. extern int rts(),swi(),stop(),wait();
  50. extern int tax(),clc(),sec(),cli(),sei(),rsp(),nop(),txa();
  51. extern int sub(),cmp(),sbc(),cpx(),and(),bit(),lda(),sta(),eor(),adc(),ora();
  52. extern int add(),jmp(),bsr(),jsr(),ldx(),stx();
  53.  
  54.  
  55. struct instruction_table_entry instr_tbl[] =
  56. {
  57.     { brset, 0, "BRSET0", 5 },
  58.     { brclr, 0, "BRCLR0", 5 },
  59.     { brset, 1, "BRSET1", 5 },
  60.     { brclr, 1, "BRCLR1", 5 },
  61.     { brset, 2, "BRSET2", 5 },
  62.     { brclr, 2, "BRCLR2", 5 },
  63.     { brset, 3, "BRSET3", 5 },
  64.     { brclr, 3, "BRCLR3", 5 },
  65.     { brset, 4, "BRSET4", 5 },
  66.     { brclr, 4, "BRCLR4", 5 },
  67.     { brset, 5, "BRSET5", 5 },
  68.     { brclr, 5, "BRCLR5", 5 },
  69.     { brset, 6, "BRSET6", 5 },
  70.     { brclr, 6, "BRCLR6", 5 },
  71.     { brset, 7, "BRSET7", 5 },
  72.     { brclr, 7, "BRCLR7", 5 },
  73.     { bset, 0, "BSET0", 5 },
  74.     { bclr, 0, "BCLR0", 5 },
  75.     { bset, 1, "BSET1", 5 },
  76.     { bclr, 1, "BCLR1", 5 },
  77.     { bset, 2, "BSET2", 5 },
  78.     { bclr, 2, "BCLR2", 5 },
  79.     { bset, 3, "BSET3", 5 },
  80.     { bclr, 3, "BCLR3", 5 },
  81.     { bset, 4, "BSET4", 5 },
  82.     { bclr, 4, "BCLR4", 5 },
  83.     { bset, 5, "BSET5", 5 },
  84.     { bclr, 5, "BCLR5", 5 },
  85.     { bset, 6, "BSET6", 5 },
  86.     { bclr, 6, "BCLR6", 5 },
  87.     { bset, 7, "BSET7", 5 },
  88.     { bclr, 7, "BCLR7", 5 },
  89.     { branch, 0, "BRA", 3 },
  90.     { branch, 1, "BRN", 3 },
  91.     { branch, 2, "BHI", 3 },
  92.     { branch, 3, "BLS", 3 },
  93.     { branch, 4, "BCC", 3 },
  94.     { branch, 5, "BCS", 3 },
  95.     { branch, 6, "BNE", 3 },
  96.     { branch, 7, "BEQ", 3 },
  97.     { branch, 8, "BHCC",3 },
  98.     { branch, 9, "BHCS",3 },
  99.     { branch, 10, "BPL",3 },
  100.     { branch, 11, "BMI",3 },
  101.     { branch, 12, "BMC",3 },
  102.     { branch, 13, "BMS",3 },
  103.     { branch, 14, "BIL",3 },
  104.     { branch, 15, "BIH",3 },
  105.     { neg,  DIRECT, "NEG", 5 },
  106.     { invalid,  DIRECT, inval_str, 0 },
  107.     { invalid,  DIRECT, inval_str, 0 },
  108.     { com,  DIRECT, "COM", 5 },
  109.     { lsr,  DIRECT, "LSR", 5 },
  110.     { invalid,  DIRECT, inval_str, 0 },
  111.     { ror,  DIRECT, "ROR", 5 },
  112.     { asr,  DIRECT, "ASR", 5 },
  113.     { lsl,  DIRECT, "LSL", 5 },
  114.     { rol,  DIRECT, "ROL", 5 },
  115.     { dec,  DIRECT, "DEC", 5 },
  116.     { invalid,  DIRECT, inval_str, 0 },
  117.     { inc,  DIRECT, "INC", 5 },
  118.     { tst,  DIRECT, "TST", 4 },
  119.     { invalid,  DIRECT, inval_str, 0 },
  120.     { clr,  DIRECT, "CLR", 5 },
  121.     { neg,  ACCUM, "NEGA", 3 },
  122.     { invalid,  ACCUM, inval_str, 0 },
  123.   /*{ invalid,  ACCUM, inval_str, 0 },*/
  124.     { mul,  INH, "MUL", 11 },
  125.     { com,  ACCUM, "COMA", 3 },
  126.     { lsr,  ACCUM, "LSRA", 3 },
  127.     { invalid,  ACCUM, inval_str, 0 },
  128.     { ror,  ACCUM, "RORA", 3 },
  129.     { asr,  ACCUM, "ASRA", 3 },
  130.     { lsl,  ACCUM, "LSLA", 3 },
  131.     { rol,  ACCUM, "ROLA", 3 },
  132.     { dec,  ACCUM, "DECA", 3 },
  133.     { invalid,  ACCUM, inval_str, 0 },
  134.     { inc,  ACCUM, "INCA", 3 },
  135.     { tst,  ACCUM, "TSTA", 3 },
  136.     { invalid,  ACCUM, inval_str, 0 },
  137.     { clr,  ACCUM, "CLRA", 3 },
  138.     { neg,  XREG, "NEGX", 3 },
  139.     { invalid,  XREG, inval_str, 0 },
  140.     { invalid,  XREG, inval_str, 0 },
  141.     { com,  XREG, "COMX", 3 },
  142.     { lsr,  XREG, "LSRX", 3 },
  143.     { invalid,  XREG, inval_str, 0 },
  144.     { ror,  XREG, "RORX", 3 },
  145.     { asr,  XREG, "ASRX", 3 },
  146.     { lsl,  XREG, "LSLX", 3 },
  147.     { rol,  XREG, "ROLX", 3 },
  148.     { dec,  XREG, "DECX", 3 },
  149.     { invalid,  XREG, inval_str, 0 },
  150.     { inc,  XREG, "INCX", 3 },
  151.     { tst,  XREG, "TSTX", 3 },
  152.     { invalid,  XREG, inval_str, 0 },
  153.     { clr,  XREG, "CLRX", 3 },
  154.     { neg,  AT_X_BYTE_OFFSET, "NEG", 6 },
  155.     { invalid,  AT_X_BYTE_OFFSET, inval_str, 0 },
  156.     { invalid,  AT_X_BYTE_OFFSET, inval_str, 0 },
  157.     { com,  AT_X_BYTE_OFFSET, "COM", 6 },
  158.     { lsr,  AT_X_BYTE_OFFSET, "LSR", 6 },
  159.     { invalid,  AT_X_BYTE_OFFSET, inval_str, 0 },
  160.     { ror,  AT_X_BYTE_OFFSET, "ROR", 6 },
  161.     { asr,  AT_X_BYTE_OFFSET, "ASR", 6 },
  162.     { lsl,  AT_X_BYTE_OFFSET, "LSL", 6 },
  163.     { rol,  AT_X_BYTE_OFFSET, "ROL", 6 },
  164.     { dec,  AT_X_BYTE_OFFSET, "DEC", 6 },
  165.     { invalid,  AT_X_BYTE_OFFSET, inval_str, 0 },
  166.     { inc,  AT_X_BYTE_OFFSET, "INC", 6 },
  167.     { tst,  AT_X_BYTE_OFFSET, "TST", 5 },
  168.     { invalid,  AT_X_BYTE_OFFSET, inval_str, 0 },
  169.     { clr,  AT_X_BYTE_OFFSET, "CLR", 6 },
  170.     { neg,  AT_X, "NEG ,X", 5 },
  171.     { invalid,  AT_X, inval_str, 0 },
  172.     { invalid,  AT_X, inval_str, 0 },
  173.     { com,  AT_X, "COM ,X", 5 },
  174.     { lsr,  AT_X, "LSR ,X", 5 },
  175.     { invalid,  AT_X, inval_str, 0 },
  176.     { ror,  AT_X, "ROR ,X", 5 },
  177.     { asr,  AT_X, "ASR ,X", 5 },
  178.     { lsl,  AT_X, "LSL ,X", 5 },
  179.     { rol,  AT_X, "ROL ,X", 5 },
  180.     { dec,  AT_X, "DEC ,X", 5 },
  181.     { invalid,  AT_X, inval_str, 0 },
  182.     { inc,  AT_X, "INC ,X", 5 },
  183.     { tst,  AT_X, "TST ,X", 4 },
  184.     { invalid,  AT_X, inval_str, 0 },
  185.     { clr,  AT_X, "CLR ,X", 5 },
  186.     { rti,  INH, "RTI", 9 },
  187.     { rts,  INH, "RTS", 6 },
  188.     { invalid,  INH, inval_str, 0 },
  189.     { swi,  INH, "SWI", 10 },
  190.     { invalid,  INH, inval_str, 0 },
  191.     { invalid,  INH, inval_str, 0 },
  192.     { invalid,  INH, inval_str, 0 },
  193.     { invalid,  INH, inval_str, 0 },
  194.     { invalid,  INH, inval_str, 0 },
  195.     { invalid,  INH, inval_str, 0 },
  196.     { invalid,  INH, inval_str, 0 },
  197.     { invalid,  INH, inval_str, 0 },
  198.     { invalid,  INH, inval_str, 0 },
  199.     { invalid,  INH, inval_str, 0 },
  200.    /* { invalid,  INH, inval_str, 0 },*/
  201.     { stop, INH, "STOP", 2 },
  202.    /* { invalid,  INH, inval_str, 0 },*/
  203.     { wait, INH, "WAIT", 2 },
  204.     { invalid,  INH, inval_str, 0 },
  205.     { invalid,  INH, inval_str, 0 },
  206.     { invalid,  INH, inval_str, 0 },
  207.     { invalid,  INH, inval_str, 0 },
  208.     { invalid,  INH, inval_str, 0 },
  209.     { invalid,  INH, inval_str, 0 },
  210.     { invalid,  INH, inval_str, 0 },
  211.     { tax, INH, "TAX", 2 },
  212.     { clc, INH, "CLC", 2 },
  213.     { sec, INH, "SEC", 2 },
  214.     { cli, INH, "CLI", 2 },
  215.     { sei, INH, "SEI", 2 },
  216.     { rsp, INH, "RSP", 2 },
  217.     { nop, INH, "NOP", 2 },
  218.     { invalid,  INH, inval_str, 0 },
  219.     { txa, INH, "TXA", 2 },
  220.     { sub, IMM, "SUB", 2 },
  221.     { cmp, IMM, "CMP", 2 },
  222.     { sbc, IMM, "SBC", 2 },
  223.     { cpx, IMM, "CPX", 2 },
  224.     { and, IMM, "AND", 2 },
  225.     { bit, IMM, "BIT", 2 },
  226.     { lda, IMM, "LDA", 2 },
  227.     { invalid,  IMM, inval_str, 0 },
  228.     { eor, IMM, "EOR", 2 },
  229.     { adc, IMM, "ADC", 2 },
  230.     { ora, IMM, "ORA", 2 },
  231.     { add, IMM, "ADD", 2 },
  232.     { invalid,  IMM, inval_str, 0 },
  233.     { bsr, REL, "BSR", 6 },
  234.     { ldx, IMM, "LDX", 2 },
  235.     { invalid,  IMM, inval_str, 0 },
  236.     { sub, DIRECT, "SUB", 3 },
  237.     { cmp, DIRECT, "CMP", 3 },
  238.     { sbc, DIRECT, "SBC", 3 },
  239.     { cpx, DIRECT, "CPX", 3 },
  240.     { and, DIRECT, "AND", 3 },
  241.     { bit, DIRECT, "BIT", 3 },
  242.     { lda, DIRECT, "LDA", 3 },
  243.     { sta, DIRECT, "STA", 4 },
  244.     { eor, DIRECT, "EOR", 3 },
  245.     { adc, DIRECT, "ADC", 3 },
  246.     { ora, DIRECT, "ORA", 3 },
  247.     { add, DIRECT, "ADD", 3 },
  248.     { jmp, DIRECT, "JMP", 2 },
  249.     { jsr, DIRECT, "JSR", 5 },
  250.     { ldx, DIRECT, "LDX", 3 },
  251.     { stx, DIRECT, "STX", 4 },
  252.     { sub, EXT, "SUB", 4 },
  253.     { cmp, EXT, "CMP", 4 },
  254.     { sbc, EXT, "SBC", 4 },
  255.     { cpx, EXT, "CPX", 4 },
  256.     { and, EXT, "AND", 4 },
  257.     { bit, EXT, "BIT", 4 },
  258.     { lda, EXT, "LDA", 4 },
  259.     { sta, EXT, "STA", 5 },
  260.     { eor, EXT, "EOR", 4 },
  261.     { adc, EXT, "ADC", 4 },
  262.     { ora, EXT, "ORA", 4 },
  263.     { add, EXT, "ADD", 4 },
  264.     { jmp, EXT, "JMP", 3 },
  265.     { jsr, EXT, "JSR", 6 },
  266.     { ldx, EXT, "LDX", 4 },
  267.     { stx, EXT, "STX", 5 },
  268.     { sub, AT_X_WORD_OFFSET, "SUB", 5 },
  269.     { cmp, AT_X_WORD_OFFSET, "CMP", 5 },
  270.     { sbc, AT_X_WORD_OFFSET, "SBC", 5 },
  271.     { cpx, AT_X_WORD_OFFSET, "CPX", 5 },
  272.     { and, AT_X_WORD_OFFSET, "AND", 5 },
  273.     { bit, AT_X_WORD_OFFSET, "BIT", 5 },
  274.     { lda, AT_X_WORD_OFFSET, "LDA", 5 },
  275.     { sta, AT_X_WORD_OFFSET, "STA", 6 },
  276.     { eor, AT_X_WORD_OFFSET, "EOR", 5 },
  277.     { adc, AT_X_WORD_OFFSET, "ADC", 5 },
  278.     { ora, AT_X_WORD_OFFSET, "ORA", 5 },
  279.     { add, AT_X_WORD_OFFSET, "ADD", 5 },
  280.     { jmp, AT_X_WORD_OFFSET, "JMP", 4 },
  281.     { jsr, AT_X_WORD_OFFSET, "JSR", 7 },
  282.     { ldx, AT_X_WORD_OFFSET, "LDX", 5 },
  283.     { stx, AT_X_WORD_OFFSET, "STX", 6 },
  284.     { sub, AT_X_BYTE_OFFSET, "SUB", 4 },
  285.     { cmp, AT_X_BYTE_OFFSET, "CMP", 4 },
  286.     { sbc, AT_X_BYTE_OFFSET, "SBC", 4 },
  287.     { cpx, AT_X_BYTE_OFFSET, "CPX", 4 },
  288.     { and, AT_X_BYTE_OFFSET, "AND", 4 },
  289.     { bit, AT_X_BYTE_OFFSET, "BIT", 4 },
  290.     { lda, AT_X_BYTE_OFFSET, "LDA", 4 },
  291.     { sta, AT_X_BYTE_OFFSET, "STA", 5 },
  292.     { eor, AT_X_BYTE_OFFSET, "EOR", 4 },
  293.     { adc, AT_X_BYTE_OFFSET, "ADC", 4 },
  294.     { ora, AT_X_BYTE_OFFSET, "ORA", 4 },
  295.     { add, AT_X_BYTE_OFFSET, "ADD", 4 },
  296.     { jmp, AT_X_BYTE_OFFSET, "JMP", 3 },
  297.     { jsr, AT_X_BYTE_OFFSET, "JSR", 6 },
  298.     { ldx, AT_X_BYTE_OFFSET, "LDX", 4 },
  299.     { stx, AT_X_BYTE_OFFSET, "STX", 5 },
  300.     { sub, AT_X, "SUB ,X", 3 },
  301.     { cmp, AT_X, "CMP ,X", 3 },
  302.     { sbc, AT_X, "SBX ,X", 3 },
  303.     { cpx, AT_X, "CPX ,X", 3 },
  304.     { and, AT_X, "AND ,X", 3 },
  305.     { bit, AT_X, "BIT ,X", 3 },
  306.     { lda, AT_X, "LDA ,X", 3 },
  307.     { sta, AT_X, "STA ,X", 4 },
  308.     { eor, AT_X, "EOR ,X", 3 },
  309.     { adc, AT_X, "ADC ,X", 3 },
  310.     { ora, AT_X, "ORA ,X", 3 },
  311.     { add, AT_X, "ADD ,X", 3 },
  312.     { jmp, AT_X, "JMP ,X", 2 },
  313.     { jsr, AT_X, "JSR ,X", 5 },
  314.     { ldx, AT_X, "LDX ,X", 3 },
  315.     { stx, AT_X, "STX ,X", 4 }
  316. };
  317.  
  318. struct program_model pgm_model;
  319.  
  320. /**********************************************************************/
  321. int sim_reset()
  322. {
  323.     /* See figure 7-7 in 6805 tech data for reset, intr handling desc */
  324.  
  325.     pgm_model.ccr = CC_I;
  326.     rsp( INH);          /* reset stack pointer to $7F */
  327.     sim_write( PORT_A_DDR, 0 );
  328.     sim_write( PORT_B_DDR, 0 );
  329.     sim_write( PORT_C_DDR,0  );
  330.     external_intr = 0;   /* clear INT request latch */
  331.     sim_write( TIMER_CONTROL, 0x7F);
  332.     sim_write( MISC_REGISTER, 0xFF);
  333.     sim_timer_init();   /* prescaler and ctr to all 1, set TCR bit */
  334.                         /* see 5-8 , 6805 tech data, for more. */
  335.     
  336.     /* Load options from MOR into control logic */
  337.     /* partially done by sim_timer_init, above */
  338.  
  339.     pgm_model.pc = (sim_read( 0xFFE) << 8) + sim_read( 0xFFF);    
  340.     cycle_count = 0;
  341. }
  342. /**********************************************************************/
  343. int get_ea( addr_mode )
  344. /* Called by most routines in instr2.c.  Returns the address from which
  345.    data is to be fetched (or to which to write), based on address mode
  346.    and an appropriate number of bytes at the current pc, which is assumed
  347.    to point to the byte after the instruction.
  348.    (Exception: bit-test-and-branch instructions call this routine twice:
  349.    the first time mode is DIRECT to get the address of the byte to test,
  350.    and the second time mode is BTB to get the address to which to branch.)
  351. */
  352. {
  353.     int retval, i, j;
  354.     char buff[40];
  355.  
  356.     switch (addr_mode)
  357.     {
  358.     case ACCUM:
  359.     retval = RW_A;
  360.     break;
  361.     case XREG:
  362.     retval = RW_X;
  363.     break;
  364.     case AT_X:
  365.     retval = pgm_model.x;
  366.     break;
  367.     case AT_X_BYTE_OFFSET:
  368.     retval = sim_read( pgm_model.pc);
  369.     if (display_enabled)
  370.     {
  371.             sprintf( buff, "   $%x,X", retval);
  372.             strcat( mne, buff);
  373.         sprintf( buff, " %02x", retval);
  374.         strcat( opcode, buff);
  375.         }
  376.     retval += pgm_model.x;
  377.     pgm_model.pc++;
  378.     break;
  379.     case AT_X_WORD_OFFSET:
  380.     i = sim_read( pgm_model.pc);
  381.     pgm_model.pc++;
  382.     j = sim_read( pgm_model.pc);
  383.     pgm_model.pc++;
  384.         retval = i * 256 + j;
  385.         if (display_enabled)
  386.         {
  387.             sprintf( buff, "   $%x,X", retval);
  388.             strcat( mne, buff);
  389.         sprintf( buff, " %02x %02x", i, j);
  390.         strcat( opcode, buff);
  391.         }
  392.     retval += pgm_model.x;
  393.     break;
  394.     case IMM:
  395.     i = sim_read( pgm_model.pc);
  396.     retval = pgm_model.pc;
  397.     pgm_model.pc++;
  398.         if (display_enabled)
  399.         {
  400.         sprintf( buff, "   #$%02x", i);
  401.             strcat( mne, buff);
  402.         sprintf( buff, " %02x", i);
  403.         strcat( opcode, buff);
  404.      }
  405.     break;    
  406.     case DIRECT:
  407.     retval = sim_read( pgm_model.pc);
  408.     pgm_model.pc++;
  409.     if (display_enabled)
  410.     {
  411.         sprintf( buff, "   $%02x", retval);
  412.             strcat( mne, buff);
  413.         sprintf( buff, " %02x", retval);
  414.         strcat( opcode, buff );
  415.     }
  416.     break;
  417.     case EXT:
  418.     i = sim_read( pgm_model.pc);
  419.     pgm_model.pc++;
  420.     j = sim_read( pgm_model.pc);
  421.     pgm_model.pc++;
  422.         retval = i * 256 + j;
  423.         if (display_enabled)
  424.         {
  425.             sprintf( buff, "   $%03x", retval);
  426.             strcat( mne, buff);
  427.         sprintf( buff, " %02x %02x", i, j);
  428.         strcat( opcode, buff);
  429.         }
  430.     break;
  431.     case BTB: /* second of two bytes for BTB - first is DIRECT, second REL */
  432.     j = i = sim_read( pgm_model.pc);
  433.     pgm_model.pc++;
  434.     if (i > 127)
  435.         i -= 256;
  436.     retval = pgm_model.pc + i;
  437.     if (display_enabled)
  438.     {
  439.         sprintf( buff, ",$%03x", retval);
  440.             strcat( mne, buff);
  441.         sprintf( buff, " %02x", j);
  442.         strcat( opcode, buff );  /* skip 2 of 3 leading spaces */
  443.     }
  444.     break;
  445.     case REL:
  446.     j = i = sim_read( pgm_model.pc);
  447.     pgm_model.pc++;
  448.     if (i > 127)
  449.         i -= 256;
  450.     retval = pgm_model.pc + i;
  451.     if (display_enabled)
  452.     {
  453.         sprintf( buff, "   $%03x", retval);
  454.             strcat( mne, buff);
  455.         sprintf( buff, " %02x", j);
  456.         strcat( opcode, buff );  /* skip 2 of 3 leading spaces */
  457.     }
  458.     break;
  459.     default:
  460.         retval = -1;
  461.     }
  462.     return( retval);
  463. }
  464. /**********************************************************************/
  465. int sim_instr()
  466. /* Called from instr_or_intr, below, to do instruction at pc */
  467. /* Also called from sim_r3.c for disassembly */
  468. {
  469.     int iopcode, i, j;
  470.  
  471.     iopcode = sim_read( pgm_model.pc );
  472.     sprintf( opcode, "%03x  %02x", pgm_model.pc, iopcode);
  473.     pgm_model.pc++;
  474.     strcpy( mne, instr_tbl[iopcode].name);
  475.     rw[0] = '\0';    /* empty string */
  476.     if (!disassemble)
  477.     sim_timer_update( instr_tbl[iopcode].ncycles );    
  478.  
  479.     (*instr_tbl[iopcode].function)( instr_tbl[iopcode].argument);
  480.  
  481.     if (!disassemble)
  482.     cycle_count += instr_tbl[iopcode].ncycles;
  483.     if (display_enabled)
  484.     {
  485.     settextposition( 7, 1);
  486.     delete_line(PROMPTLINE+2);
  487.     settextposition( 49, 1);
  488.     printf( "%s", opcode );
  489.     settextposition( 49, 19);
  490.     printf( "%s", mne);
  491.     if (!disassemble)
  492.     {
  493.         settextposition( 49, 40);
  494.         printf( "%s", rw); /* nothing in rw if disassemble, see append_rw*/
  495.         settextposition( 49, 70);
  496.         printf( "%9ld", cycle_count);
  497.     }
  498.     settextposition( PROMPTLINE, 1);  /* return cursor to default pos */
  499.     
  500.     if (log_enabled)       /* Note: never true if disassemble */
  501.     {
  502.         fprintf( logfile, "%s", opcode);
  503.             i = strlen( opcode);
  504.         fprintf( logfile, "%s", &blanks[40-19+i]);
  505.         fprintf( logfile, "%s", mne );
  506.         i = strlen( mne);
  507.         fprintf( logfile, "%s", &blanks[40-(40-19)+i]);
  508.         fprintf( logfile, "%s", rw);
  509.         i = strlen( rw);
  510.         fprintf( logfile, "%s", &blanks[40-(70-40)+i]);
  511.         fprintf( logfile, "%9ld\n", cycle_count);
  512.     }
  513.     }
  514. }
  515. /**********************************************************************/
  516. int pull()
  517. /* The 6805 has no user "pull" instruction.  That's why this routine is
  518.    here, instead of in instr2.c.  This routine used by rts, rti in instr2
  519. */
  520. {
  521.     if (pgm_model.sp < 0x7F)
  522.     pgm_model.sp++;
  523.     else
  524.     pgm_model.sp = 0x61;
  525.     return( sim_read( pgm_model.sp));
  526. }
  527. /**********************************************************************/
  528. int push( value)
  529. int value;
  530. /* The 6805 series has no user "push" instruction.  That's why this routine
  531.    is here, instead of in instr2.c.  This routine used by 'interrupt', below
  532. */
  533. {
  534.     sim_write( pgm_model.sp, value);
  535.     if (pgm_model.sp > 0x61)
  536.     pgm_model.sp--;
  537.     else
  538.     pgm_model.sp = 0x7F; 
  539. }
  540. /**********************************************************************/
  541. int rinterrupt( vector_addr)
  542. /* Stack registers, fetch vector, and display a message */
  543. {
  544.     push( pgm_model.pc & 0xFF);                /* PCL */
  545.     push( ((pgm_model.pc & 0xF00) >> 8) | 0xF0 );    /* PCH */
  546.     push( pgm_model.x);                    /*  X  */
  547.     push( pgm_model.a);                    /*  A  */
  548.     push( pgm_model.ccr | 0xE0 );            /* CCR */
  549.     pgm_model.ccr |= CC_I;   /* Mask interrupts */
  550.     pgm_model.pc = sim_read( vector_addr)  * 256;
  551.     pgm_model.pc += sim_read( vector_addr + 1 ) ;
  552.     pgm_model.pc &= 4095;
  553.     if (display_enabled)
  554.     {
  555.     settextposition( 7, 1);
  556.     delete_line(PROMPTLINE+2);
  557.     settextposition( 49, 1);
  558.     if (vector_addr == 0xFFC)
  559.        printf( "==> Interrupt service, SWI");
  560.     else if (vector_addr == 0xFFA)
  561.        printf( "==> Interrupt service, INT");
  562.     else if (vector_addr == 0xFF8)
  563.        printf( "==> Interrupt service, INT2 or TIMER");
  564.     if (pgm_model.sp > 0x7A)
  565.        printf("   *** WARNING: Stack overflow");
  566.     if (log_enabled)
  567.     {
  568.         if (vector_addr == 0xFFC)
  569.             fprintf(logfile, "==> Interrupt service, SWI");
  570.         else if (vector_addr == 0xFFA)
  571.             fprintf(logfile, "==> Interrupt service, INT");
  572.         else if (vector_addr == 0xFF8)
  573.             fprintf(logfile, "==> Interrupt service, INT2 or TIMER");
  574.         if (pgm_model.sp > 0x7A)
  575.             fprintf(logfile,"   *** WARNING: Stack overflow\n");
  576.         else
  577.         fprintf(logfile, "\n");
  578.     }
  579.     }
  580. }
  581. /**********************************************************************/
  582. int instr_or_intr()
  583. /* called from main to do one instruction */
  584. {
  585.     int i,j;
  586.  
  587.     if (!(pgm_model.ccr & CC_I))
  588.     {
  589.     if (external_intr)
  590.     {
  591.         external_intr = 0;   /* clear INT request latch */
  592.         rinterrupt( 0xFFA);   /* vector address = INT */
  593.     }
  594.     else
  595.     {
  596.         i = sim_read( TIMER_CONTROL);
  597.         j = sim_read( MISC_REGISTER);
  598.         if ( (( i & 0xC0) == 0x80) || ((j & 0xC0) == 0x80) )
  599.         rinterrupt( 0xFF8); /* vector address = timer or INT2 */
  600.     }
  601.     }
  602.     sim_instr();    /* SWI is handled as a regular instruction */
  603. }
  604.  
  605. /**********************************************************************/
  606. append_rw( readflag, addr, data)
  607. int readflag;   /* 1 = Read, 0 = Write */
  608. int addr, data;
  609. /* Used by routines in instr2.c to show bytes read, written */
  610. {
  611.     char buff[50];
  612.     char *sym_tbl_ptr;
  613.     int *sym_nmbr_ptr, ndx;
  614.  
  615.     sym_nmbr_ptr = sym_nmbr;
  616.  
  617.     if (display_enabled && !disassemble)
  618.     {
  619.     if (addr >= 0)
  620.     {
  621. /* Symbol table "linked list" */
  622.         if (( ndx = *( sym_nmbr_ptr +  addr)) >= 4096)
  623.         {
  624.           sym_tbl_ptr = sym_tbl;
  625.           sym_tbl_ptr += ndx - 4096;
  626.  
  627.           if (readflag)
  628.         sprintf( buff, "%s=>%02x ", sym_tbl_ptr, data);
  629.           else
  630.         sprintf( buff, "%s<=%02x ", sym_tbl_ptr, data);
  631.           goto endloop;
  632.         }
  633.  
  634.         if (readflag)
  635.         sprintf( buff, "%03x=>%02x ", addr, data);
  636.         else
  637.         sprintf( buff, "%03x<=%02x ", addr, data);
  638.     }
  639.     else
  640.     {
  641.         char rname[20];
  642.  
  643.         if (addr == RW_A)
  644.         strcpy( rname, "ACCUM");
  645.         else if (addr == RW_X)
  646.         strcpy( rname, "X_REG");
  647.         else if (addr == RW_SP)
  648.         strcpy( rname, "SP");
  649.         if (readflag)
  650.         sprintf( buff, "%s=>%02x ", rname, data);
  651.         else
  652.         sprintf( buff, "%s<=%02x ", rname, data);
  653.     }
  654. endloop:
  655. ;
  656.  
  657.        strcat( rw, buff);
  658.     }
  659. }
  660.  
  661.  
  662.  
  663. delete_line( lineno)
  664. int lineno;
  665. {
  666. #ifdef MSC
  667.  
  668.     union REGS regs;
  669.  
  670.     lineno--;            /* DOS BIOS counts lines from 0, not 1 */
  671.     regs.h.ah = 6;       /* Service 6 = scroll text window up */
  672.     regs.h.al = 1;       /* Number of lines to scroll up */
  673.     regs.h.ch = lineno;  /* row# of up left */
  674.     regs.h.cl = 0;       /* column# of up left */
  675.     regs.h.dh = 49;      /* row# of low right */
  676.     regs.h.dl = 79;      /* column# of low right */
  677.     regs.h.bh = 7;       /* foreground white, background black, no blink */
  678.     int86( 16, ®s, ®s);
  679. #endif
  680. #ifdef VT52
  681.     settextposition( lineno, 1);
  682.     printf("\033M");    /* escape M = delete line the cursor is on */
  683.             /* the rest moves up one line, last line is free */
  684. #endif
  685. }
  686.  
  687. /************************ end of file instr.c ***************************/
  688.